//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Billingconductor service.
///
/// Amazon Web Services Billing Conductor is a fully managed service that you can use to customize a proforma version of your billing data each month, to accurately show or chargeback your end customers. Amazon Web Services Billing Conductor doesn't change the way you're billed by Amazon Web Services each month by design. Instead, it provides you with a mechanism to configure, generate, and display rates to certain customers over a given billing period. You can also analyze the difference between the rates you apply to your accounting groupings relative to your actual rates from Amazon Web Services. As a result of your Amazon Web Services Billing Conductor configuration, the payer account can also see the custom rate applied on the billing details page of the Amazon Web Services Billing console, or configure a cost and usage report per billing group. This documentation shows how you can configure Amazon Web Services Billing Conductor using its API. For more information about using the Amazon Web Services Billing Conductor user interface, see the  Amazon Web Services Billing Conductor User Guide.
public struct Billingconductor: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Billingconductor client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: nil,
            partition: partition,
            serviceName: "Billingconductor",
            serviceIdentifier: "billingconductor",
            serviceProtocol: .restjson,
            apiVersion: "2021-07-30",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            partitionEndpoints: Self.partitionEndpoints,
            errorType: BillingconductorErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "aws-global": "billingconductor.us-east-1.amazonaws.com"
    ]}

    /// Default endpoint and region to use for each partition
    static var partitionEndpoints: [AWSPartition: (endpoint: String, region: SotoCore.Region)] {[
        .aws: (endpoint: "aws-global", region: .useast1)
    ]}


    // MARK: API Calls

    /// Connects an array of account IDs in a consolidated billing family to a predefined billing group. The account IDs must be a part of the consolidated billing family during the current month, and not already associated with another billing group. The maximum number of accounts that can be associated in one call is 30.
    @Sendable
    @inlinable
    public func associateAccounts(_ input: AssociateAccountsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateAccountsOutput {
        try await self.client.execute(
            operation: "AssociateAccounts", 
            path: "/associate-accounts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Connects an array of account IDs in a consolidated billing family to a predefined billing group. The account IDs must be a part of the consolidated billing family during the current month, and not already associated with another billing group. The maximum number of accounts that can be associated in one call is 30.
    ///
    /// Parameters:
    ///   - accountIds:  The associating array of account IDs.
    ///   - arn:  The Amazon Resource Name (ARN) of the billing group that associates the array of account IDs.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateAccounts(
        accountIds: [String],
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateAccountsOutput {
        let input = AssociateAccountsInput(
            accountIds: accountIds, 
            arn: arn
        )
        return try await self.associateAccounts(input, logger: logger)
    }

    /// Connects an array of PricingRuleArns to a defined PricingPlan. The maximum number PricingRuleArn that can be associated in one call is 30.
    @Sendable
    @inlinable
    public func associatePricingRules(_ input: AssociatePricingRulesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociatePricingRulesOutput {
        try await self.client.execute(
            operation: "AssociatePricingRules", 
            path: "/associate-pricing-rules", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Connects an array of PricingRuleArns to a defined PricingPlan. The maximum number PricingRuleArn that can be associated in one call is 30.
    ///
    /// Parameters:
    ///   - arn:  The PricingPlanArn that the PricingRuleArns are associated with.
    ///   - pricingRuleArns:  The PricingRuleArns that are associated with the Pricing Plan.
    ///   - logger: Logger use during operation
    @inlinable
    public func associatePricingRules(
        arn: String,
        pricingRuleArns: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociatePricingRulesOutput {
        let input = AssociatePricingRulesInput(
            arn: arn, 
            pricingRuleArns: pricingRuleArns
        )
        return try await self.associatePricingRules(input, logger: logger)
    }

    ///  Associates a batch of resources to a percentage custom line item.
    @Sendable
    @inlinable
    public func batchAssociateResourcesToCustomLineItem(_ input: BatchAssociateResourcesToCustomLineItemInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchAssociateResourcesToCustomLineItemOutput {
        try await self.client.execute(
            operation: "BatchAssociateResourcesToCustomLineItem", 
            path: "/batch-associate-resources-to-custom-line-item", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Associates a batch of resources to a percentage custom line item.
    ///
    /// Parameters:
    ///   - billingPeriodRange: 
    ///   - resourceArns:  A list containing the ARNs of the resources to be associated.
    ///   - targetArn:  A percentage custom line item ARN to associate the resources to.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchAssociateResourcesToCustomLineItem(
        billingPeriodRange: CustomLineItemBillingPeriodRange? = nil,
        resourceArns: [String],
        targetArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchAssociateResourcesToCustomLineItemOutput {
        let input = BatchAssociateResourcesToCustomLineItemInput(
            billingPeriodRange: billingPeriodRange, 
            resourceArns: resourceArns, 
            targetArn: targetArn
        )
        return try await self.batchAssociateResourcesToCustomLineItem(input, logger: logger)
    }

    ///  Disassociates a batch of resources from a percentage custom line item.
    @Sendable
    @inlinable
    public func batchDisassociateResourcesFromCustomLineItem(_ input: BatchDisassociateResourcesFromCustomLineItemInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDisassociateResourcesFromCustomLineItemOutput {
        try await self.client.execute(
            operation: "BatchDisassociateResourcesFromCustomLineItem", 
            path: "/batch-disassociate-resources-from-custom-line-item", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Disassociates a batch of resources from a percentage custom line item.
    ///
    /// Parameters:
    ///   - billingPeriodRange: 
    ///   - resourceArns:  A list containing the ARNs of resources to be disassociated.
    ///   - targetArn:  A percentage custom line item ARN to disassociate the resources from.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDisassociateResourcesFromCustomLineItem(
        billingPeriodRange: CustomLineItemBillingPeriodRange? = nil,
        resourceArns: [String],
        targetArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDisassociateResourcesFromCustomLineItemOutput {
        let input = BatchDisassociateResourcesFromCustomLineItemInput(
            billingPeriodRange: billingPeriodRange, 
            resourceArns: resourceArns, 
            targetArn: targetArn
        )
        return try await self.batchDisassociateResourcesFromCustomLineItem(input, logger: logger)
    }

    ///  Creates a billing group that resembles a consolidated billing family that Amazon Web Services charges, based off of the predefined pricing plan computation.
    @Sendable
    @inlinable
    public func createBillingGroup(_ input: CreateBillingGroupInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateBillingGroupOutput {
        try await self.client.execute(
            operation: "CreateBillingGroup", 
            path: "/create-billing-group", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a billing group that resembles a consolidated billing family that Amazon Web Services charges, based off of the predefined pricing plan computation.
    ///
    /// Parameters:
    ///   - accountGrouping:  The set of accounts that will be under the billing group. The set of accounts resemble the linked accounts in a consolidated billing family.
    ///   - clientToken:  The token that is needed to support idempotency. Idempotency isn't currently supported, but will be implemented in a future update.
    ///   - computationPreference:  The preferences and settings that will be used to compute the Amazon Web Services charges for a billing group.
    ///   - description: The description of the billing group.
    ///   - name:  The billing group name. The names must be unique.
    ///   - primaryAccountId:  The account ID that serves as the main account in a billing group.
    ///   - tags:  A map that contains tag keys and tag values that are attached to a billing group. This feature isn't available during the beta.
    ///   - logger: Logger use during operation
    @inlinable
    public func createBillingGroup(
        accountGrouping: AccountGrouping,
        clientToken: String? = CreateBillingGroupInput.idempotencyToken(),
        computationPreference: ComputationPreference,
        description: String? = nil,
        name: String,
        primaryAccountId: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateBillingGroupOutput {
        let input = CreateBillingGroupInput(
            accountGrouping: accountGrouping, 
            clientToken: clientToken, 
            computationPreference: computationPreference, 
            description: description, 
            name: name, 
            primaryAccountId: primaryAccountId, 
            tags: tags
        )
        return try await self.createBillingGroup(input, logger: logger)
    }

    /// Creates a custom line item that can be used to create a one-time fixed charge that can be applied to a single billing group for the current or previous billing period. The one-time fixed charge is either a fee or discount.
    @Sendable
    @inlinable
    public func createCustomLineItem(_ input: CreateCustomLineItemInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCustomLineItemOutput {
        try await self.client.execute(
            operation: "CreateCustomLineItem", 
            path: "/create-custom-line-item", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a custom line item that can be used to create a one-time fixed charge that can be applied to a single billing group for the current or previous billing period. The one-time fixed charge is either a fee or discount.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Web Services account in which this custom line item will be applied to.
    ///   - billingGroupArn:  The Amazon Resource Name (ARN) that references the billing group where the custom line item applies to.
    ///   - billingPeriodRange:  A time range for which the custom line item is effective.
    ///   - chargeDetails:  A CustomLineItemChargeDetails that describes the charge details for a custom line item.
    ///   - clientToken:  The token that is needed to support idempotency. Idempotency isn't currently supported, but will be implemented in a future update.
    ///   - description:  The description of the custom line item. This is shown on the Bills page in association with the charge value.
    ///   - name:  The name of the custom line item.
    ///   - tags:  A map that contains tag keys and tag values that are attached to a custom line item.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCustomLineItem(
        accountId: String? = nil,
        billingGroupArn: String,
        billingPeriodRange: CustomLineItemBillingPeriodRange? = nil,
        chargeDetails: CustomLineItemChargeDetails,
        clientToken: String? = CreateCustomLineItemInput.idempotencyToken(),
        description: String,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCustomLineItemOutput {
        let input = CreateCustomLineItemInput(
            accountId: accountId, 
            billingGroupArn: billingGroupArn, 
            billingPeriodRange: billingPeriodRange, 
            chargeDetails: chargeDetails, 
            clientToken: clientToken, 
            description: description, 
            name: name, 
            tags: tags
        )
        return try await self.createCustomLineItem(input, logger: logger)
    }

    /// Creates a pricing plan that is used for computing Amazon Web Services charges for billing groups.
    @Sendable
    @inlinable
    public func createPricingPlan(_ input: CreatePricingPlanInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePricingPlanOutput {
        try await self.client.execute(
            operation: "CreatePricingPlan", 
            path: "/create-pricing-plan", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a pricing plan that is used for computing Amazon Web Services charges for billing groups.
    ///
    /// Parameters:
    ///   - clientToken:  The token that is needed to support idempotency. Idempotency isn't currently supported, but will be implemented in a future update.
    ///   - description: The description of the pricing plan.
    ///   - name: The name of the pricing plan. The names must be unique to each pricing plan.
    ///   - pricingRuleArns:  A list of Amazon Resource Names (ARNs) that define the pricing plan parameters.
    ///   - tags:  A map that contains tag keys and tag values that are attached to a pricing plan.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPricingPlan(
        clientToken: String? = CreatePricingPlanInput.idempotencyToken(),
        description: String? = nil,
        name: String,
        pricingRuleArns: [String]? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePricingPlanOutput {
        let input = CreatePricingPlanInput(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            pricingRuleArns: pricingRuleArns, 
            tags: tags
        )
        return try await self.createPricingPlan(input, logger: logger)
    }

    ///  Creates a pricing rule can be associated to a pricing plan, or a set of pricing plans.
    @Sendable
    @inlinable
    public func createPricingRule(_ input: CreatePricingRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePricingRuleOutput {
        try await self.client.execute(
            operation: "CreatePricingRule", 
            path: "/create-pricing-rule", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a pricing rule can be associated to a pricing plan, or a set of pricing plans.
    ///
    /// Parameters:
    ///   - billingEntity:  The seller of services provided by Amazon Web Services, their affiliates, or third-party providers selling services via Amazon Web Services Marketplace.
    ///   - clientToken:  The token that's needed to support idempotency. Idempotency isn't currently supported, but will be implemented in a future update.
    ///   - description:  The pricing rule description.
    ///   - modifierPercentage:  A percentage modifier that's applied on the public pricing rates.
    ///   - name:  The pricing rule name. The names must be unique to each pricing rule.
    ///   - operation:  Operation is the specific Amazon Web Services action covered by this line item. This describes the specific usage of the line item.  If the Scope attribute is set to SKU, this attribute indicates which operation the PricingRule is modifying. For example, a value of RunInstances:0202 indicates the operation of running an Amazon EC2 instance.
    ///   - scope:  The scope of pricing rule that indicates if it's globally applicable, or it's service-specific.
    ///   - service:  If the Scope attribute is set to SERVICE or SKU, the attribute indicates which service the PricingRule is applicable for.
    ///   - tags:  A map that contains tag keys and tag values that are attached to a pricing rule.
    ///   - tiering:  The set of tiering configurations for the pricing rule.
    ///   - type:  The type of pricing rule.
    ///   - usageType:  Usage type is the unit that each service uses to measure the usage of a specific type of resource. If the Scope attribute is set to SKU, this attribute indicates which usage type the PricingRule is modifying. For example, USW2-BoxUsage:m2.2xlarge describes an M2 High Memory Double Extra Large instance in the US West (Oregon) Region.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPricingRule(
        billingEntity: String? = nil,
        clientToken: String? = CreatePricingRuleInput.idempotencyToken(),
        description: String? = nil,
        modifierPercentage: Double? = nil,
        name: String,
        operation: String? = nil,
        scope: PricingRuleScope,
        service: String? = nil,
        tags: [String: String]? = nil,
        tiering: CreateTieringInput? = nil,
        type: PricingRuleType,
        usageType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePricingRuleOutput {
        let input = CreatePricingRuleInput(
            billingEntity: billingEntity, 
            clientToken: clientToken, 
            description: description, 
            modifierPercentage: modifierPercentage, 
            name: name, 
            operation: operation, 
            scope: scope, 
            service: service, 
            tags: tags, 
            tiering: tiering, 
            type: type, 
            usageType: usageType
        )
        return try await self.createPricingRule(input, logger: logger)
    }

    ///  Deletes a billing group.
    @Sendable
    @inlinable
    public func deleteBillingGroup(_ input: DeleteBillingGroupInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteBillingGroupOutput {
        try await self.client.execute(
            operation: "DeleteBillingGroup", 
            path: "/delete-billing-group", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a billing group.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the billing group that you're deleting.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteBillingGroup(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteBillingGroupOutput {
        let input = DeleteBillingGroupInput(
            arn: arn
        )
        return try await self.deleteBillingGroup(input, logger: logger)
    }

    ///  Deletes the custom line item identified by the given ARN in the current, or previous billing period.
    @Sendable
    @inlinable
    public func deleteCustomLineItem(_ input: DeleteCustomLineItemInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCustomLineItemOutput {
        try await self.client.execute(
            operation: "DeleteCustomLineItem", 
            path: "/delete-custom-line-item", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes the custom line item identified by the given ARN in the current, or previous billing period.
    ///
    /// Parameters:
    ///   - arn:  The ARN of the custom line item to be deleted.
    ///   - billingPeriodRange: 
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCustomLineItem(
        arn: String,
        billingPeriodRange: CustomLineItemBillingPeriodRange? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCustomLineItemOutput {
        let input = DeleteCustomLineItemInput(
            arn: arn, 
            billingPeriodRange: billingPeriodRange
        )
        return try await self.deleteCustomLineItem(input, logger: logger)
    }

    /// Deletes a pricing plan. The pricing plan must not be associated with any billing groups to delete successfully.
    @Sendable
    @inlinable
    public func deletePricingPlan(_ input: DeletePricingPlanInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePricingPlanOutput {
        try await self.client.execute(
            operation: "DeletePricingPlan", 
            path: "/delete-pricing-plan", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a pricing plan. The pricing plan must not be associated with any billing groups to delete successfully.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the pricing plan that you're deleting.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePricingPlan(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePricingPlanOutput {
        let input = DeletePricingPlanInput(
            arn: arn
        )
        return try await self.deletePricingPlan(input, logger: logger)
    }

    ///  Deletes the pricing rule that's identified by the input Amazon Resource Name (ARN).
    @Sendable
    @inlinable
    public func deletePricingRule(_ input: DeletePricingRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePricingRuleOutput {
        try await self.client.execute(
            operation: "DeletePricingRule", 
            path: "/delete-pricing-rule", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes the pricing rule that's identified by the input Amazon Resource Name (ARN).
    ///
    /// Parameters:
    ///   - arn:  The Amazon Resource Name (ARN) of the pricing rule that you are deleting.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePricingRule(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePricingRuleOutput {
        let input = DeletePricingRuleInput(
            arn: arn
        )
        return try await self.deletePricingRule(input, logger: logger)
    }

    /// Removes the specified list of account IDs from the given billing group.
    @Sendable
    @inlinable
    public func disassociateAccounts(_ input: DisassociateAccountsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateAccountsOutput {
        try await self.client.execute(
            operation: "DisassociateAccounts", 
            path: "/disassociate-accounts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified list of account IDs from the given billing group.
    ///
    /// Parameters:
    ///   - accountIds: The array of account IDs to disassociate.
    ///   - arn: The Amazon Resource Name (ARN) of the billing group that the array of account IDs will disassociate from.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateAccounts(
        accountIds: [String],
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateAccountsOutput {
        let input = DisassociateAccountsInput(
            accountIds: accountIds, 
            arn: arn
        )
        return try await self.disassociateAccounts(input, logger: logger)
    }

    ///  Disassociates a list of pricing rules from a pricing plan.
    @Sendable
    @inlinable
    public func disassociatePricingRules(_ input: DisassociatePricingRulesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociatePricingRulesOutput {
        try await self.client.execute(
            operation: "DisassociatePricingRules", 
            path: "/disassociate-pricing-rules", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Disassociates a list of pricing rules from a pricing plan.
    ///
    /// Parameters:
    ///   - arn:  The pricing plan Amazon Resource Name (ARN) to disassociate pricing rules from.
    ///   - pricingRuleArns:  A list containing the Amazon Resource Name (ARN) of the pricing rules that will be disassociated.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociatePricingRules(
        arn: String,
        pricingRuleArns: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociatePricingRulesOutput {
        let input = DisassociatePricingRulesInput(
            arn: arn, 
            pricingRuleArns: pricingRuleArns
        )
        return try await self.disassociatePricingRules(input, logger: logger)
    }

    /// Retrieves the margin summary report, which includes the Amazon Web Services cost and charged  amount (pro forma cost) by Amazon Web Service for a specific billing group.
    @Sendable
    @inlinable
    public func getBillingGroupCostReport(_ input: GetBillingGroupCostReportInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetBillingGroupCostReportOutput {
        try await self.client.execute(
            operation: "GetBillingGroupCostReport", 
            path: "/get-billing-group-cost-report", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the margin summary report, which includes the Amazon Web Services cost and charged  amount (pro forma cost) by Amazon Web Service for a specific billing group.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Number (ARN) that uniquely identifies the billing group.
    ///   - billingPeriodRange: A time range for which the margin summary is effective. You can specify up to 12 months.
    ///   - groupBy: A list of strings that specify the attributes that are used to break down costs in the margin summary reports for the billing group. For example, you can view your costs by the Amazon Web Service name or the billing period.
    ///   - maxResults: The maximum number of margin summary reports to retrieve.
    ///   - nextToken: The pagination token used on subsequent calls to get reports.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBillingGroupCostReport(
        arn: String,
        billingPeriodRange: BillingPeriodRange? = nil,
        groupBy: [GroupByAttributeName]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBillingGroupCostReportOutput {
        let input = GetBillingGroupCostReportInput(
            arn: arn, 
            billingPeriodRange: billingPeriodRange, 
            groupBy: groupBy, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getBillingGroupCostReport(input, logger: logger)
    }

    ///  This is a paginated call to list linked accounts that are linked to the payer account for the specified time period. If no information is provided, the current billing period is used. The response will optionally include the billing group that's associated with the linked account.
    @Sendable
    @inlinable
    public func listAccountAssociations(_ input: ListAccountAssociationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAccountAssociationsOutput {
        try await self.client.execute(
            operation: "ListAccountAssociations", 
            path: "/list-account-associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  This is a paginated call to list linked accounts that are linked to the payer account for the specified time period. If no information is provided, the current billing period is used. The response will optionally include the billing group that's associated with the linked account.
    ///
    /// Parameters:
    ///   - billingPeriod:  The preferred billing period to get account associations.
    ///   - filters: The filter on the account ID of the linked account, or any of the following:  MONITORED: linked accounts that are associated to billing groups.  UNMONITORED: linked accounts that aren't associated to billing groups.  Billing Group Arn: linked accounts that are associated to the provided billing group Arn.
    ///   - nextToken:  The pagination token that's used on subsequent calls to retrieve accounts.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAccountAssociations(
        billingPeriod: String? = nil,
        filters: ListAccountAssociationsFilter? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAccountAssociationsOutput {
        let input = ListAccountAssociationsInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            nextToken: nextToken
        )
        return try await self.listAccountAssociations(input, logger: logger)
    }

    /// A paginated call to retrieve a summary report of actual Amazon Web Services charges and the calculated Amazon Web Services charges based on the associated pricing plan of a billing group.
    @Sendable
    @inlinable
    public func listBillingGroupCostReports(_ input: ListBillingGroupCostReportsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBillingGroupCostReportsOutput {
        try await self.client.execute(
            operation: "ListBillingGroupCostReports", 
            path: "/list-billing-group-cost-reports", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A paginated call to retrieve a summary report of actual Amazon Web Services charges and the calculated Amazon Web Services charges based on the associated pricing plan of a billing group.
    ///
    /// Parameters:
    ///   - billingPeriod: The preferred billing period for your report.
    ///   - filters: A ListBillingGroupCostReportsFilter to specify billing groups to retrieve reports from.
    ///   - maxResults: The maximum number of reports to retrieve.
    ///   - nextToken: The pagination token that's used on subsequent calls to get reports.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBillingGroupCostReports(
        billingPeriod: String? = nil,
        filters: ListBillingGroupCostReportsFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBillingGroupCostReportsOutput {
        let input = ListBillingGroupCostReportsInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listBillingGroupCostReports(input, logger: logger)
    }

    /// A paginated call to retrieve a list of billing groups for the given billing period. If you don't provide a billing group, the current billing period is used.
    @Sendable
    @inlinable
    public func listBillingGroups(_ input: ListBillingGroupsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBillingGroupsOutput {
        try await self.client.execute(
            operation: "ListBillingGroups", 
            path: "/list-billing-groups", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A paginated call to retrieve a list of billing groups for the given billing period. If you don't provide a billing group, the current billing period is used.
    ///
    /// Parameters:
    ///   - billingPeriod: The preferred billing period to get billing groups.
    ///   - filters: A ListBillingGroupsFilter that specifies the billing group and pricing plan to retrieve billing group information.
    ///   - maxResults: The maximum number of billing groups to retrieve.
    ///   - nextToken: The pagination token that's used on subsequent calls to get billing groups.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBillingGroups(
        billingPeriod: String? = nil,
        filters: ListBillingGroupsFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBillingGroupsOutput {
        let input = ListBillingGroupsInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listBillingGroups(input, logger: logger)
    }

    /// A paginated call to get a list of all custom line item versions.
    @Sendable
    @inlinable
    public func listCustomLineItemVersions(_ input: ListCustomLineItemVersionsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCustomLineItemVersionsOutput {
        try await self.client.execute(
            operation: "ListCustomLineItemVersions", 
            path: "/list-custom-line-item-versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A paginated call to get a list of all custom line item versions.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) for the custom line item.
    ///   - filters: A ListCustomLineItemVersionsFilter that specifies the billing period range in which the custom line item versions are applied.
    ///   - maxResults: The maximum number of custom line item versions to retrieve.
    ///   - nextToken: The pagination token that's used on subsequent calls to retrieve custom line item versions.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCustomLineItemVersions(
        arn: String,
        filters: ListCustomLineItemVersionsFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCustomLineItemVersionsOutput {
        let input = ListCustomLineItemVersionsInput(
            arn: arn, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCustomLineItemVersions(input, logger: logger)
    }

    ///  A paginated call to get a list of all custom line items (FFLIs) for the given billing period. If you don't provide a billing period, the current billing period is used.
    @Sendable
    @inlinable
    public func listCustomLineItems(_ input: ListCustomLineItemsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCustomLineItemsOutput {
        try await self.client.execute(
            operation: "ListCustomLineItems", 
            path: "/list-custom-line-items", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  A paginated call to get a list of all custom line items (FFLIs) for the given billing period. If you don't provide a billing period, the current billing period is used.
    ///
    /// Parameters:
    ///   - billingPeriod:  The preferred billing period to get custom line items (FFLIs).
    ///   - filters: A ListCustomLineItemsFilter that specifies the custom line item names and/or billing group Amazon Resource Names (ARNs) to retrieve FFLI information.
    ///   - maxResults:  The maximum number of billing groups to retrieve.
    ///   - nextToken:  The pagination token that's used on subsequent calls to get custom line items (FFLIs).
    ///   - logger: Logger use during operation
    @inlinable
    public func listCustomLineItems(
        billingPeriod: String? = nil,
        filters: ListCustomLineItemsFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCustomLineItemsOutput {
        let input = ListCustomLineItemsInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCustomLineItems(input, logger: logger)
    }

    /// A paginated call to get pricing plans for the given billing period. If you don't provide a billing period, the current billing period is used.
    @Sendable
    @inlinable
    public func listPricingPlans(_ input: ListPricingPlansInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPricingPlansOutput {
        try await self.client.execute(
            operation: "ListPricingPlans", 
            path: "/list-pricing-plans", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A paginated call to get pricing plans for the given billing period. If you don't provide a billing period, the current billing period is used.
    ///
    /// Parameters:
    ///   - billingPeriod: The preferred billing period to get pricing plan.
    ///   - filters: A ListPricingPlansFilter that specifies the Amazon Resource Name (ARNs) of pricing plans to retrieve pricing plans information.
    ///   - maxResults: The maximum number of pricing plans to retrieve.
    ///   - nextToken: The pagination token that's used on subsequent call to get pricing plans.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPricingPlans(
        billingPeriod: String? = nil,
        filters: ListPricingPlansFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPricingPlansOutput {
        let input = ListPricingPlansInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPricingPlans(input, logger: logger)
    }

    ///  A list of the pricing plans that are associated with a pricing rule.
    @Sendable
    @inlinable
    public func listPricingPlansAssociatedWithPricingRule(_ input: ListPricingPlansAssociatedWithPricingRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPricingPlansAssociatedWithPricingRuleOutput {
        try await self.client.execute(
            operation: "ListPricingPlansAssociatedWithPricingRule", 
            path: "/list-pricing-plans-associated-with-pricing-rule", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  A list of the pricing plans that are associated with a pricing rule.
    ///
    /// Parameters:
    ///   - billingPeriod:  The pricing plan billing period for which associations will be listed.
    ///   - maxResults:  The optional maximum number of pricing rule associations to retrieve.
    ///   - nextToken:  The optional pagination token returned by a previous call.
    ///   - pricingRuleArn:  The pricing rule Amazon Resource Name (ARN) for which associations will be listed.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPricingPlansAssociatedWithPricingRule(
        billingPeriod: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        pricingRuleArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPricingPlansAssociatedWithPricingRuleOutput {
        let input = ListPricingPlansAssociatedWithPricingRuleInput(
            billingPeriod: billingPeriod, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            pricingRuleArn: pricingRuleArn
        )
        return try await self.listPricingPlansAssociatedWithPricingRule(input, logger: logger)
    }

    ///  Describes a pricing rule that can be associated to a pricing plan, or set of pricing plans.
    @Sendable
    @inlinable
    public func listPricingRules(_ input: ListPricingRulesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPricingRulesOutput {
        try await self.client.execute(
            operation: "ListPricingRules", 
            path: "/list-pricing-rules", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Describes a pricing rule that can be associated to a pricing plan, or set of pricing plans.
    ///
    /// Parameters:
    ///   - billingPeriod:  The preferred billing period to get the pricing plan.
    ///   - filters:  A DescribePricingRuleFilter that specifies the Amazon Resource Name (ARNs) of pricing rules to retrieve pricing rules information.
    ///   - maxResults:  The maximum number of pricing rules to retrieve.
    ///   - nextToken:  The pagination token that's used on subsequent call to get pricing rules.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPricingRules(
        billingPeriod: String? = nil,
        filters: ListPricingRulesFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPricingRulesOutput {
        let input = ListPricingRulesInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPricingRules(input, logger: logger)
    }

    ///  Lists the pricing rules that are associated with a pricing plan.
    @Sendable
    @inlinable
    public func listPricingRulesAssociatedToPricingPlan(_ input: ListPricingRulesAssociatedToPricingPlanInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPricingRulesAssociatedToPricingPlanOutput {
        try await self.client.execute(
            operation: "ListPricingRulesAssociatedToPricingPlan", 
            path: "/list-pricing-rules-associated-to-pricing-plan", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Lists the pricing rules that are associated with a pricing plan.
    ///
    /// Parameters:
    ///   - billingPeriod:  The billing period for which the pricing rule associations are to be listed.
    ///   - maxResults: The optional maximum number of pricing rule associations to retrieve.
    ///   - nextToken:  The optional pagination token returned by a previous call.
    ///   - pricingPlanArn:  The Amazon Resource Name (ARN) of the pricing plan for which associations are to be listed.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPricingRulesAssociatedToPricingPlan(
        billingPeriod: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        pricingPlanArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPricingRulesAssociatedToPricingPlanOutput {
        let input = ListPricingRulesAssociatedToPricingPlanInput(
            billingPeriod: billingPeriod, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            pricingPlanArn: pricingPlanArn
        )
        return try await self.listPricingRulesAssociatedToPricingPlan(input, logger: logger)
    }

    ///  List the resources that are associated to a custom line item.
    @Sendable
    @inlinable
    public func listResourcesAssociatedToCustomLineItem(_ input: ListResourcesAssociatedToCustomLineItemInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListResourcesAssociatedToCustomLineItemOutput {
        try await self.client.execute(
            operation: "ListResourcesAssociatedToCustomLineItem", 
            path: "/list-resources-associated-to-custom-line-item", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  List the resources that are associated to a custom line item.
    ///
    /// Parameters:
    ///   - arn:  The ARN of the custom line item for which the resource associations will be listed.
    ///   - billingPeriod:  The billing period for which the resource associations will be listed.
    ///   - filters:  (Optional) A ListResourcesAssociatedToCustomLineItemFilter that can specify the types of resources that should be retrieved.
    ///   - maxResults:  (Optional) The maximum number of resource associations to be retrieved.
    ///   - nextToken:  (Optional) The pagination token that's returned by a previous request.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourcesAssociatedToCustomLineItem(
        arn: String,
        billingPeriod: String? = nil,
        filters: ListResourcesAssociatedToCustomLineItemFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourcesAssociatedToCustomLineItemOutput {
        let input = ListResourcesAssociatedToCustomLineItemInput(
            arn: arn, 
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listResourcesAssociatedToCustomLineItem(input, logger: logger)
    }

    ///  A list the tags for a resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  A list the tags for a resource.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) that identifies the resource to list the tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    ///  Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) of the resource to which to add tags.
    ///   - tags:  The tags to add to the resource as a list of key-value pairs.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    ///  Deletes specified tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes specified tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) of the resource to which to delete tags.
    ///   - tagKeys:  The tags to delete from the resource as a list of key-value pairs.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// This updates an existing billing group.
    @Sendable
    @inlinable
    public func updateBillingGroup(_ input: UpdateBillingGroupInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBillingGroupOutput {
        try await self.client.execute(
            operation: "UpdateBillingGroup", 
            path: "/update-billing-group", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This updates an existing billing group.
    ///
    /// Parameters:
    ///   - accountGrouping: Specifies if the billing group has automatic account
    ///   - arn: The Amazon Resource Name (ARN) of the billing group being updated.
    ///   - computationPreference:  The preferences and settings that will be used to compute the Amazon Web Services charges for a billing group.
    ///   - description: A description of the billing group.
    ///   - name: The name of the billing group. The names must be unique to each billing group.
    ///   - status: The status of the billing group. Only one of the valid values can be used.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBillingGroup(
        accountGrouping: UpdateBillingGroupAccountGrouping? = nil,
        arn: String,
        computationPreference: ComputationPreference? = nil,
        description: String? = nil,
        name: String? = nil,
        status: BillingGroupStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBillingGroupOutput {
        let input = UpdateBillingGroupInput(
            accountGrouping: accountGrouping, 
            arn: arn, 
            computationPreference: computationPreference, 
            description: description, 
            name: name, 
            status: status
        )
        return try await self.updateBillingGroup(input, logger: logger)
    }

    ///  Update an existing custom line item in the current or previous billing period.
    @Sendable
    @inlinable
    public func updateCustomLineItem(_ input: UpdateCustomLineItemInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCustomLineItemOutput {
        try await self.client.execute(
            operation: "UpdateCustomLineItem", 
            path: "/update-custom-line-item", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Update an existing custom line item in the current or previous billing period.
    ///
    /// Parameters:
    ///   - arn:  The ARN of the custom line item to be updated.
    ///   - billingPeriodRange: 
    ///   - chargeDetails:  A ListCustomLineItemChargeDetails containing the new charge details for the custom line item.
    ///   - description:  The new line item description of the custom line item.
    ///   - name:  The new name for the custom line item.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCustomLineItem(
        arn: String,
        billingPeriodRange: CustomLineItemBillingPeriodRange? = nil,
        chargeDetails: UpdateCustomLineItemChargeDetails? = nil,
        description: String? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCustomLineItemOutput {
        let input = UpdateCustomLineItemInput(
            arn: arn, 
            billingPeriodRange: billingPeriodRange, 
            chargeDetails: chargeDetails, 
            description: description, 
            name: name
        )
        return try await self.updateCustomLineItem(input, logger: logger)
    }

    /// This updates an existing pricing plan.
    @Sendable
    @inlinable
    public func updatePricingPlan(_ input: UpdatePricingPlanInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePricingPlanOutput {
        try await self.client.execute(
            operation: "UpdatePricingPlan", 
            path: "/update-pricing-plan", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This updates an existing pricing plan.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the pricing plan that you're updating.
    ///   - description: The description of the pricing plan.
    ///   - name: The name of the pricing plan. The name must be unique to each pricing plan.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePricingPlan(
        arn: String,
        description: String? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePricingPlanOutput {
        let input = UpdatePricingPlanInput(
            arn: arn, 
            description: description, 
            name: name
        )
        return try await self.updatePricingPlan(input, logger: logger)
    }

    ///  Updates an existing pricing rule.
    @Sendable
    @inlinable
    public func updatePricingRule(_ input: UpdatePricingRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePricingRuleOutput {
        try await self.client.execute(
            operation: "UpdatePricingRule", 
            path: "/update-pricing-rule", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates an existing pricing rule.
    ///
    /// Parameters:
    ///   - arn:  The Amazon Resource Name (ARN) of the pricing rule to update.
    ///   - description:  The new description for the pricing rule.
    ///   - modifierPercentage:  The new modifier to show pricing plan rates as a percentage.
    ///   - name:  The new name of the pricing rule. The name must be unique to each pricing rule.
    ///   - tiering:  The set of tiering configurations for the pricing rule.
    ///   - type:  The new pricing rule type.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePricingRule(
        arn: String,
        description: String? = nil,
        modifierPercentage: Double? = nil,
        name: String? = nil,
        tiering: UpdateTieringInput? = nil,
        type: PricingRuleType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePricingRuleOutput {
        let input = UpdatePricingRuleInput(
            arn: arn, 
            description: description, 
            modifierPercentage: modifierPercentage, 
            name: name, 
            tiering: tiering, 
            type: type
        )
        return try await self.updatePricingRule(input, logger: logger)
    }
}

extension Billingconductor {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Billingconductor, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Billingconductor {
    /// Return PaginatorSequence for operation ``getBillingGroupCostReport(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getBillingGroupCostReportPaginator(
        _ input: GetBillingGroupCostReportInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetBillingGroupCostReportInput, GetBillingGroupCostReportOutput> {
        return .init(
            input: input,
            command: self.getBillingGroupCostReport,
            inputKey: \GetBillingGroupCostReportInput.nextToken,
            outputKey: \GetBillingGroupCostReportOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getBillingGroupCostReport(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The Amazon Resource Number (ARN) that uniquely identifies the billing group.
    ///   - billingPeriodRange: A time range for which the margin summary is effective. You can specify up to 12 months.
    ///   - groupBy: A list of strings that specify the attributes that are used to break down costs in the margin summary reports for the billing group. For example, you can view your costs by the Amazon Web Service name or the billing period.
    ///   - maxResults: The maximum number of margin summary reports to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func getBillingGroupCostReportPaginator(
        arn: String,
        billingPeriodRange: BillingPeriodRange? = nil,
        groupBy: [GroupByAttributeName]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetBillingGroupCostReportInput, GetBillingGroupCostReportOutput> {
        let input = GetBillingGroupCostReportInput(
            arn: arn, 
            billingPeriodRange: billingPeriodRange, 
            groupBy: groupBy, 
            maxResults: maxResults
        )
        return self.getBillingGroupCostReportPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAccountAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccountAssociationsPaginator(
        _ input: ListAccountAssociationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAccountAssociationsInput, ListAccountAssociationsOutput> {
        return .init(
            input: input,
            command: self.listAccountAssociations,
            inputKey: \ListAccountAssociationsInput.nextToken,
            outputKey: \ListAccountAssociationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAccountAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - billingPeriod:  The preferred billing period to get account associations.
    ///   - filters: The filter on the account ID of the linked account, or any of the following:  MONITORED: linked accounts that are associated to billing groups.  UNMONITORED: linked accounts that aren't associated to billing groups.  Billing Group Arn: linked accounts that are associated to the provided billing group Arn.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccountAssociationsPaginator(
        billingPeriod: String? = nil,
        filters: ListAccountAssociationsFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAccountAssociationsInput, ListAccountAssociationsOutput> {
        let input = ListAccountAssociationsInput(
            billingPeriod: billingPeriod, 
            filters: filters
        )
        return self.listAccountAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listBillingGroupCostReports(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBillingGroupCostReportsPaginator(
        _ input: ListBillingGroupCostReportsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBillingGroupCostReportsInput, ListBillingGroupCostReportsOutput> {
        return .init(
            input: input,
            command: self.listBillingGroupCostReports,
            inputKey: \ListBillingGroupCostReportsInput.nextToken,
            outputKey: \ListBillingGroupCostReportsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBillingGroupCostReports(_:logger:)``.
    ///
    /// - Parameters:
    ///   - billingPeriod: The preferred billing period for your report.
    ///   - filters: A ListBillingGroupCostReportsFilter to specify billing groups to retrieve reports from.
    ///   - maxResults: The maximum number of reports to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBillingGroupCostReportsPaginator(
        billingPeriod: String? = nil,
        filters: ListBillingGroupCostReportsFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBillingGroupCostReportsInput, ListBillingGroupCostReportsOutput> {
        let input = ListBillingGroupCostReportsInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults
        )
        return self.listBillingGroupCostReportsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listBillingGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBillingGroupsPaginator(
        _ input: ListBillingGroupsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBillingGroupsInput, ListBillingGroupsOutput> {
        return .init(
            input: input,
            command: self.listBillingGroups,
            inputKey: \ListBillingGroupsInput.nextToken,
            outputKey: \ListBillingGroupsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBillingGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - billingPeriod: The preferred billing period to get billing groups.
    ///   - filters: A ListBillingGroupsFilter that specifies the billing group and pricing plan to retrieve billing group information.
    ///   - maxResults: The maximum number of billing groups to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBillingGroupsPaginator(
        billingPeriod: String? = nil,
        filters: ListBillingGroupsFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBillingGroupsInput, ListBillingGroupsOutput> {
        let input = ListBillingGroupsInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults
        )
        return self.listBillingGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCustomLineItemVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomLineItemVersionsPaginator(
        _ input: ListCustomLineItemVersionsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCustomLineItemVersionsInput, ListCustomLineItemVersionsOutput> {
        return .init(
            input: input,
            command: self.listCustomLineItemVersions,
            inputKey: \ListCustomLineItemVersionsInput.nextToken,
            outputKey: \ListCustomLineItemVersionsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCustomLineItemVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The Amazon Resource Name (ARN) for the custom line item.
    ///   - filters: A ListCustomLineItemVersionsFilter that specifies the billing period range in which the custom line item versions are applied.
    ///   - maxResults: The maximum number of custom line item versions to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomLineItemVersionsPaginator(
        arn: String,
        filters: ListCustomLineItemVersionsFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCustomLineItemVersionsInput, ListCustomLineItemVersionsOutput> {
        let input = ListCustomLineItemVersionsInput(
            arn: arn, 
            filters: filters, 
            maxResults: maxResults
        )
        return self.listCustomLineItemVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCustomLineItems(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomLineItemsPaginator(
        _ input: ListCustomLineItemsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCustomLineItemsInput, ListCustomLineItemsOutput> {
        return .init(
            input: input,
            command: self.listCustomLineItems,
            inputKey: \ListCustomLineItemsInput.nextToken,
            outputKey: \ListCustomLineItemsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCustomLineItems(_:logger:)``.
    ///
    /// - Parameters:
    ///   - billingPeriod:  The preferred billing period to get custom line items (FFLIs).
    ///   - filters: A ListCustomLineItemsFilter that specifies the custom line item names and/or billing group Amazon Resource Names (ARNs) to retrieve FFLI information.
    ///   - maxResults:  The maximum number of billing groups to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomLineItemsPaginator(
        billingPeriod: String? = nil,
        filters: ListCustomLineItemsFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCustomLineItemsInput, ListCustomLineItemsOutput> {
        let input = ListCustomLineItemsInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults
        )
        return self.listCustomLineItemsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPricingPlans(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricingPlansPaginator(
        _ input: ListPricingPlansInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPricingPlansInput, ListPricingPlansOutput> {
        return .init(
            input: input,
            command: self.listPricingPlans,
            inputKey: \ListPricingPlansInput.nextToken,
            outputKey: \ListPricingPlansOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPricingPlans(_:logger:)``.
    ///
    /// - Parameters:
    ///   - billingPeriod: The preferred billing period to get pricing plan.
    ///   - filters: A ListPricingPlansFilter that specifies the Amazon Resource Name (ARNs) of pricing plans to retrieve pricing plans information.
    ///   - maxResults: The maximum number of pricing plans to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricingPlansPaginator(
        billingPeriod: String? = nil,
        filters: ListPricingPlansFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPricingPlansInput, ListPricingPlansOutput> {
        let input = ListPricingPlansInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults
        )
        return self.listPricingPlansPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPricingPlansAssociatedWithPricingRule(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricingPlansAssociatedWithPricingRulePaginator(
        _ input: ListPricingPlansAssociatedWithPricingRuleInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPricingPlansAssociatedWithPricingRuleInput, ListPricingPlansAssociatedWithPricingRuleOutput> {
        return .init(
            input: input,
            command: self.listPricingPlansAssociatedWithPricingRule,
            inputKey: \ListPricingPlansAssociatedWithPricingRuleInput.nextToken,
            outputKey: \ListPricingPlansAssociatedWithPricingRuleOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPricingPlansAssociatedWithPricingRule(_:logger:)``.
    ///
    /// - Parameters:
    ///   - billingPeriod:  The pricing plan billing period for which associations will be listed.
    ///   - maxResults:  The optional maximum number of pricing rule associations to retrieve.
    ///   - pricingRuleArn:  The pricing rule Amazon Resource Name (ARN) for which associations will be listed.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricingPlansAssociatedWithPricingRulePaginator(
        billingPeriod: String? = nil,
        maxResults: Int? = nil,
        pricingRuleArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPricingPlansAssociatedWithPricingRuleInput, ListPricingPlansAssociatedWithPricingRuleOutput> {
        let input = ListPricingPlansAssociatedWithPricingRuleInput(
            billingPeriod: billingPeriod, 
            maxResults: maxResults, 
            pricingRuleArn: pricingRuleArn
        )
        return self.listPricingPlansAssociatedWithPricingRulePaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPricingRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricingRulesPaginator(
        _ input: ListPricingRulesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPricingRulesInput, ListPricingRulesOutput> {
        return .init(
            input: input,
            command: self.listPricingRules,
            inputKey: \ListPricingRulesInput.nextToken,
            outputKey: \ListPricingRulesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPricingRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - billingPeriod:  The preferred billing period to get the pricing plan.
    ///   - filters:  A DescribePricingRuleFilter that specifies the Amazon Resource Name (ARNs) of pricing rules to retrieve pricing rules information.
    ///   - maxResults:  The maximum number of pricing rules to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricingRulesPaginator(
        billingPeriod: String? = nil,
        filters: ListPricingRulesFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPricingRulesInput, ListPricingRulesOutput> {
        let input = ListPricingRulesInput(
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults
        )
        return self.listPricingRulesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPricingRulesAssociatedToPricingPlan(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricingRulesAssociatedToPricingPlanPaginator(
        _ input: ListPricingRulesAssociatedToPricingPlanInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPricingRulesAssociatedToPricingPlanInput, ListPricingRulesAssociatedToPricingPlanOutput> {
        return .init(
            input: input,
            command: self.listPricingRulesAssociatedToPricingPlan,
            inputKey: \ListPricingRulesAssociatedToPricingPlanInput.nextToken,
            outputKey: \ListPricingRulesAssociatedToPricingPlanOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPricingRulesAssociatedToPricingPlan(_:logger:)``.
    ///
    /// - Parameters:
    ///   - billingPeriod:  The billing period for which the pricing rule associations are to be listed.
    ///   - maxResults: The optional maximum number of pricing rule associations to retrieve.
    ///   - pricingPlanArn:  The Amazon Resource Name (ARN) of the pricing plan for which associations are to be listed.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricingRulesAssociatedToPricingPlanPaginator(
        billingPeriod: String? = nil,
        maxResults: Int? = nil,
        pricingPlanArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPricingRulesAssociatedToPricingPlanInput, ListPricingRulesAssociatedToPricingPlanOutput> {
        let input = ListPricingRulesAssociatedToPricingPlanInput(
            billingPeriod: billingPeriod, 
            maxResults: maxResults, 
            pricingPlanArn: pricingPlanArn
        )
        return self.listPricingRulesAssociatedToPricingPlanPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listResourcesAssociatedToCustomLineItem(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourcesAssociatedToCustomLineItemPaginator(
        _ input: ListResourcesAssociatedToCustomLineItemInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListResourcesAssociatedToCustomLineItemInput, ListResourcesAssociatedToCustomLineItemOutput> {
        return .init(
            input: input,
            command: self.listResourcesAssociatedToCustomLineItem,
            inputKey: \ListResourcesAssociatedToCustomLineItemInput.nextToken,
            outputKey: \ListResourcesAssociatedToCustomLineItemOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listResourcesAssociatedToCustomLineItem(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn:  The ARN of the custom line item for which the resource associations will be listed.
    ///   - billingPeriod:  The billing period for which the resource associations will be listed.
    ///   - filters:  (Optional) A ListResourcesAssociatedToCustomLineItemFilter that can specify the types of resources that should be retrieved.
    ///   - maxResults:  (Optional) The maximum number of resource associations to be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourcesAssociatedToCustomLineItemPaginator(
        arn: String,
        billingPeriod: String? = nil,
        filters: ListResourcesAssociatedToCustomLineItemFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListResourcesAssociatedToCustomLineItemInput, ListResourcesAssociatedToCustomLineItemOutput> {
        let input = ListResourcesAssociatedToCustomLineItemInput(
            arn: arn, 
            billingPeriod: billingPeriod, 
            filters: filters, 
            maxResults: maxResults
        )
        return self.listResourcesAssociatedToCustomLineItemPaginator(input, logger: logger)
    }
}

extension Billingconductor.GetBillingGroupCostReportInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.GetBillingGroupCostReportInput {
        return .init(
            arn: self.arn,
            billingPeriodRange: self.billingPeriodRange,
            groupBy: self.groupBy,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Billingconductor.ListAccountAssociationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListAccountAssociationsInput {
        return .init(
            billingPeriod: self.billingPeriod,
            filters: self.filters,
            nextToken: token
        )
    }
}

extension Billingconductor.ListBillingGroupCostReportsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListBillingGroupCostReportsInput {
        return .init(
            billingPeriod: self.billingPeriod,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Billingconductor.ListBillingGroupsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListBillingGroupsInput {
        return .init(
            billingPeriod: self.billingPeriod,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Billingconductor.ListCustomLineItemVersionsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListCustomLineItemVersionsInput {
        return .init(
            arn: self.arn,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Billingconductor.ListCustomLineItemsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListCustomLineItemsInput {
        return .init(
            billingPeriod: self.billingPeriod,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Billingconductor.ListPricingPlansAssociatedWithPricingRuleInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListPricingPlansAssociatedWithPricingRuleInput {
        return .init(
            billingPeriod: self.billingPeriod,
            maxResults: self.maxResults,
            nextToken: token,
            pricingRuleArn: self.pricingRuleArn
        )
    }
}

extension Billingconductor.ListPricingPlansInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListPricingPlansInput {
        return .init(
            billingPeriod: self.billingPeriod,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Billingconductor.ListPricingRulesAssociatedToPricingPlanInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListPricingRulesAssociatedToPricingPlanInput {
        return .init(
            billingPeriod: self.billingPeriod,
            maxResults: self.maxResults,
            nextToken: token,
            pricingPlanArn: self.pricingPlanArn
        )
    }
}

extension Billingconductor.ListPricingRulesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListPricingRulesInput {
        return .init(
            billingPeriod: self.billingPeriod,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Billingconductor.ListResourcesAssociatedToCustomLineItemInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Billingconductor.ListResourcesAssociatedToCustomLineItemInput {
        return .init(
            arn: self.arn,
            billingPeriod: self.billingPeriod,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
